// 导入Player脚本
import player from "./Player";
// 导入Move_camera_Game脚本
import cam from "./Move_camera_Game";
const {ccclass, property} = cc._decorator;

@ccclass
export default class Game_Controller extends cc.Component {


    @property({displayName: "按下攻击按钮时的图片", tooltip: "按下攻击按钮时的图片", type: cc.SpriteFrame})
    attack_btn0: cc.SpriteFrame = null;

    @property({displayName: "松开攻击按钮时的图片", tooltip: "松开攻击按钮时的图片", type: cc.SpriteFrame})
    attack_btn1: cc.SpriteFrame = null;

    @property({displayName: "攻击按钮", tooltip: "攻击按钮", type: cc.Sprite})
    attack_btn: cc.Sprite = null;




    @property({displayName: "通关传送门", tooltip: "通关传送门", type: cc.Node})
    pass_door: cc.Node = null;

    @property({displayName: "显示金币的文字", tooltip: "显示金币的文字", type: cc.Label})
    money_lb: cc.Label = null;

    @property({displayName: "暂停按钮", tooltip: "暂停按钮", type: cc.Node})
    pause_btn: cc.Node = null;

    @property({displayName: "继续按钮", tooltip: "继续按钮", type: cc.Node})
    un_pause_btn: cc.Node = null;



    @property({displayName: "没有武器时的图标", tooltip: "没有武器时的图标", type: cc.Node})
    weapon_no: cc.Node = null;

    @property({displayName: "有武器时的图标", tooltip: "有武器时的图标", type: cc.Node})
    weapon_yes: cc.Node = null;

    @property({displayName: "武器图标精灵", tooltip: "武器图标精灵", type: cc.Sprite})
    weapon_sp: cc.Sprite = null;



    @property({displayName: "武器图标", tooltip: "武器图标，用于显示在武器栏上面", type: cc.SpriteFrame})
    weapon_icon: cc.SpriteFrame[] = [];





    @property({displayName: "橙色字体", tooltip: "橙色字体", type: cc.Font})
    orange_typeface: cc.Font = null;

    @property({displayName: "暴击字体", tooltip: "暴击字体", type: cc.Font})
    damage_typeface: cc.Font = null;

    @property({displayName: "绿色字体", tooltip: "绿色字体", type: cc.Font})
    green_typeface: cc.Font = null;

   /*  @property({displayName: "绿色字体", tooltip: "绿色字体", type: cc.Font})
    money_typeface: cc.Font = null; */





    @property(cc.Node)
    canvas: cc.Node = null;


    @property({displayName: "第几关", tooltip: "第几关", type: cc.Float})
    map_num: number = 1;


    @property({displayName: "移动相机脚本所在节点", tooltip: "移动相机脚本所在节点", type: cam})
    cam: cam = null;

    @property({displayName: "player脚本所在节点", tooltip: "player脚本所在节点", type: player})
    player: player = null;




    @property({displayName: "地图，有几关绑定几个", tooltip: "地图，有几关绑定几个", type: cc.Node})
    map: cc.Node[] = [];




    @property({displayName: "第一波小怪生成几个", tooltip: "第一波小怪生成几个", type: cc.Float})
    cre_1: number = 5;

    @property({displayName: "第二波小怪生成几个", tooltip: "第二波小怪生成几个", type: cc.Float})
    cre_2: number = 5;

    @property({displayName: "第三波小怪生成几个", tooltip: "第三波小怪生成几个", type: cc.Float})
    cre_3: number = 5;



    @property({displayName: "生成小怪的时间间隔", tooltip: "生成小怪的时间间隔", type: cc.Float})
    cre_time_interval: number = 2;
   



    @property({displayName: "第一波小怪预制体", tooltip: "第一波小怪预制体，有几关绑定几个", type: cc.Prefab})
    item1: cc.Prefab[] = [];

    @property({displayName: "第二波小怪预制体", tooltip: "第二波小怪预制体，有几关绑定几个", type: cc.Prefab})
    item2: cc.Prefab[] = [];

    @property({displayName: "第三波小怪预制体", tooltip: "第三波小怪预制体，有几关绑定几个", type: cc.Prefab})
    item3: cc.Prefab[] = [];

    @property({displayName: "BOSS预制体", tooltip: "BOSS预制体，有几关绑定几个", type: cc.Prefab})
    itemBOSS: cc.Prefab[] = [];

    @property({displayName: "怪物属性！", tooltip: "在这里修改小怪和BOSS的属性，0为小怪生命，1为小怪攻击，2为BOSS生命，3为BOSS攻击", type: cc.Vec4})
    item_ATK_HP: cc.Vec4[] = [];

    @property({displayName: "武器属性！", tooltip: "武器属性，顺序为生命值，魔法值，攻击力，防御力", type: cc.Vec4})
    weapon_property: cc.Vec4[] = [];

    @property({displayName: "武器暴击属性！", tooltip: "武器暴击属性", type: cc.Float})
    weapon_property_CRI: number[] = [];

    @property({displayName: "武器数据面板！", tooltip: "武器数据面板", type: cc.Node})
    weapon_UI: cc.Node = null;

    @property({displayName: "显示武器数据的文字", tooltip: "显示武器数据的文字，顺序为 名称 生命值 魔法值 攻击力 防御力 暴击率", type: cc.Label})
    weapon_UI_lb: cc.Label[] = [];

    @property({displayName: "武器的名称", tooltip: "武器的名称", type: cc.String})
    weapon_name: string[] = [];

    /*
    Foe脚本属性如下
    HP_full
    HP_cur
    ATK_num
    Skill_num
    */


    @property({displayName: "小怪和BOSS掉落物品概率", tooltip: "小怪和BOSS掉落物品概率", type: cc.Float})
    drop_probability: number = 0;


    @property({displayName: "小怪和BOSS击杀后的经验值", tooltip: "小怪和BOSS击杀后的经验值", type: cc.Vec2})
    add_EXP_num: cc.Vec2[] = [];


    @property({displayName: "小怪和BOSS击杀后的钱", tooltip: "小怪和BOSS击杀后的钱", type: cc.Vec2})
    add_money_num: cc.Vec2[] = [];


    @property({displayName: "三波小怪死亡后会掉落什么，预制体", tooltip: "三波小怪死亡后会掉落什么，预制体，最终掉落物品会在这里面随机选择", type: cc.Prefab})
    item_drop: cc.Prefab[] = [];


    @property({displayName: "BOSS死亡后会掉落什么，预制体", tooltip: "BOSS死亡后会掉落什么，预制体，有几关绑定几个", type: cc.Prefab})
    item_drop_boos: cc.Prefab[] = [];


    // 武器属性
    W_property: number[] = [];

    weapon: number = null;



    // 第一波小兵是否生成
    is_1: boolean = true;
    // 第一波小兵生成位置
    x_1: number = 0;

    // 第二波小兵是否生成
    is_2: boolean = true;
    // 第二波小兵生成位置
    x_2: number = 0;

    // 第三波小兵是否生成
    is_3: boolean = true;
    // 第三波小兵生成位置
    x_3: number = 0;

    // BOSS是否生成
    is_BOSS: boolean = true;


    onLoad () {
        let self = this;
        
        // 获取一下是第几关
        this.map_num = Number(cc.sys.localStorage.getItem("map"));

        // 获取装备的武器
        let w = cc.sys.localStorage.getItem("weapon");
        // 如果武器为null
        if (w == null) {
        } else {
            // 如果武器不为null就用变量存起来
            this.weapon = Number(w);
        }


        // 隐藏所有地图
        for (let i = 0; i < this.map.length; i ++) {
            this.map[i].active = false;
        }

        // 显示指定地图
        let map = this.map[this.map_num - 1];
        // 给移动相机的脚本的背景赋值
        this.cam.bg = map;
        // 显示地图
        map.active = true;

        // 第一波小怪刷新地
        let node1 = map.children[0];
        let x1 = node1.x + map.x;
        this.x_1 = x1;

        // 第二波小怪刷新地
        let node2 = map.children[1];
        let x2 = node2.x + map.x;
        this.x_2 = x2;

        // 第三波小怪刷新地
        let node3 = map.children[2];
        let x3 = node3.x + map.x;
        this.x_3 = x3;
        // cc.log(x1,x2, x3);

        // 如果没有武器
        if (this.weapon == null) {
            // 图标显示为没有武器
            this.weapon_no.active = true;
            this.weapon_yes.active = false;
        } else {
            // 图标显示为有武器
            this.weapon_no.active = false;
            this.weapon_yes.active = true;
            // 显示武器的图标
            this.weapon_sp.spriteFrame = this.weapon_icon[this.weapon - 1];   
        }



        // 当手指触摸到武器图标时显示武器的属性
        // 松开手指时隐藏武器的属性
        this.weapon_yes.on(cc.Node.EventType.TOUCH_START, function () {
            self.weapon_UI.active = true;
        }, this);

        this.weapon_sp.node.on(cc.Node.EventType.TOUCH_START, function () {
            self.weapon_UI.active = true;
        }, this);

        this.weapon_yes.on(cc.Node.EventType.TOUCH_END, function () {
            self.weapon_UI.active = false;
        }, this);

        this.weapon_sp.node.on(cc.Node.EventType.TOUCH_END, function () {
            self.weapon_UI.active = false;
        }, this);

        this.weapon_yes.on(cc.Node.EventType.TOUCH_CANCEL, function () {
            self.weapon_UI.active = false;
        }, this);

        this.weapon_sp.node.on(cc.Node.EventType.TOUCH_CANCEL, function () {
            self.weapon_UI.active = false;
        }, this);





        // 如果武器不为null
        if (this.weapon != null) {
            // 显示武器的属性
            this.weapon_UI_lb[0].string = "名称：" + this.weapon_name[this.weapon - 1];
            this.weapon_UI_lb[1].string = "生命值：" + this.weapon_property[this.weapon - 1].x;
            this.weapon_UI_lb[2].string = "魔法值：" + this.weapon_property[this.weapon - 1].y;
            this.weapon_UI_lb[3].string = "攻击力：" + this.weapon_property[this.weapon - 1].z;
            this.weapon_UI_lb[4].string = "防御力：" + this.weapon_property[this.weapon - 1].w;
            this.weapon_UI_lb[5].string = "暴击率：" + (this.weapon_property_CRI[this.weapon - 1]) * 100 + "%";
        }


        // 如果武器不为null
        if (this.weapon != null) {
            // 获取武器属性
            this.W_property[0] = this.weapon_property[this.weapon - 1].x;
            this.W_property[1] = this.weapon_property[this.weapon - 1].y;
            this.W_property[2] = this.weapon_property[this.weapon - 1].z;
            this.W_property[3] = this.weapon_property[this.weapon - 1].w;
            this.W_property[4] = this.weapon_property_CRI[this.weapon - 1];
        }

        // 最后一关比较特殊，传送门要往上来点
        if (this.map_num == 11) {
            this.pass_door.y = -40;
        } else if (this.map_num == 4) {
            this.pass_door.y = -160;
        } else if (this.map_num == 5) {
            this.pass_door.y = -180;
        } else if (this.map_num == 8) {
            this.pass_door.y = -160;
        } else if (this.map_num == 10) {
            this.pass_door.y = -180;
        }




        // 给攻击按钮绑定事件
        // 当按下攻击按钮时显示一个图片，松开后显示另一个图片
        this.attack_btn.node.on(cc.Node.EventType.TOUCH_START, function () {
            self.attack_btn.spriteFrame = self.attack_btn0;
        }, this);


        this.attack_btn.node.on(cc.Node.EventType.TOUCH_END, function () {
            self.attack_btn.spriteFrame = self.attack_btn1;
        }, this);


        this.attack_btn.node.on(cc.Node.EventType.TOUCH_CANCEL, function () {
            self.attack_btn.spriteFrame = self.attack_btn1;
        }, this);
    }


    update () {

        // 如果有武器
        if (this.weapon != null) {
            // 最终血量为   
            this.player.full_HP = this.player.HP_num + this.W_property[0];
            // 最终魔法为
            this.player.full_MP = this.player.MP_num + this.W_property[1];
            // 最终攻击力为   普通攻击力 乘 攻击力提高倍率
            this.player.ATK = (this.player.ATK_num * this.player.ATK_promote) + this.W_property[2];
            // 最终防御力为
            this.player.AC = (this.player.AC_num * this.player.AC_promote) + this.W_property[3];
            // 最终暴击率为
            this.player.CRI = this.player.CRI_num + (this.W_property[4]) * 100;
        }
        // 如果没有武器 
        else {
            // 最终血量为   
            this.player.full_HP = this.player.HP_num;
            // 最终魔法为
            this.player.full_MP = this.player.MP_num;
            // 最终攻击力为   普通攻击力 乘 攻击力提高倍率
            this.player.ATK = (this.player.ATK_num * this.player.ATK_promote);
            // 最终防御力为
            this.player.AC = (this.player.AC_num * this.player.AC_promote);
            // 最终暴击率为
            this.player.CRI = this.player.CRI_num;
        }




        let self = this;

        // cc.log("角色位置:", this.player.player.node.x, "第一波小怪刷新位置:", this.x_1);
        // 如果可以刷新第一波小怪了
        if (this.is_1 == true && this.player.player.node.x > this.x_1) {
            // 不可以再次刷新
            this.is_1 = false;
            //cc.log("第一波小怪已经生成！！！！！！！");


            // for循环生成小怪
            for (let i = 0; i < this.cre_1; i ++) {

                // 每隔几秒刷新
                this.scheduleOnce(function () {
                    // 生成新的小怪
                    let node = cc.instantiate(self.item1[this.map_num - 1]);
                    // 父节点为canvas
                    node.parent = this.canvas;
                    // 坐标为生成点
                    node.position = cc.v3(this.x_1, 0);

                    // 获取Foe脚本
                    let foe = node.getComponent("Foe");
                    // 设置小怪的满血量，当前血量和攻击力
                    foe.HP_full = self.item_ATK_HP[self.map_num - 1].x;
                    foe.HP_cur = self.item_ATK_HP[self.map_num - 1].x;
                    foe.ATK_num = self.item_ATK_HP[self.map_num - 1].y;

                    cc.log("第一波小怪已经生成！！！！！！！");
                }, i * this.cre_time_interval);

            }
        }
        // 如果可以刷新第二波小怪
        if (this.is_2 == true && this.player.player.node.x > this.x_2) {
            // 不可以再次刷新
            this.is_2 = false;
            //cc.log("第二波小怪已经生成！！！！！！！");


            // for循环生成小怪
            for (let i = 0; i < this.cre_2; i ++) {

                // 每隔几秒生成一次
                this.scheduleOnce(function () {
                    // 生成小怪
                    let node = cc.instantiate(self.item2[this.map_num - 1]);
                    // 父节点为canvas
                    node.parent = this.canvas;
                    // 坐标为第二次刷新点
                    node.position = cc.v3(this.x_2, 0);

                    // 获取Foe脚本
                    let foe = node.getComponent("Foe");
                    // 设置小怪满的血量，当前血量和攻击力
                    foe.HP_full = self.item_ATK_HP[self.map_num - 1].x;
                    foe.HP_cur = self.item_ATK_HP[self.map_num - 1].x;
                    foe.ATK_num = self.item_ATK_HP[self.map_num - 1].y;

                    cc.log("第二波小怪已经生成！！！！！！！");
                }, i * this.cre_time_interval);

            }
        }
        // 如果可以刷新第三波小怪
        if (this.is_3 == true && this.player.player.node.x > this.x_3) {
            // 不可以再次刷新
            this.is_3 = false;
            // cc.log("第三波小怪已经生成！！！！！！！");


            // foe循环生成小怪
            for (let i = 0; i < this.cre_3; i ++) {

                // 每隔几秒生成一次
                this.scheduleOnce(function () {
                    // 生成小怪
                    let node = cc.instantiate(self.item3[this.map_num - 1]);
                    // 父节点为canvas
                    node.parent = this.canvas;
                    //坐标为第三波刷新点
                    node.position = cc.v3(this.x_3, 0);

                    // 获取Foe脚本
                    let foe = node.getComponent("Foe");
                    // 设置小怪满的血量和当前血量
                    foe.HP_full = self.item_ATK_HP[self.map_num - 1].x;
                    foe.HP_cur = self.item_ATK_HP[self.map_num - 1].x;
                    foe.ATK_num = self.item_ATK_HP[self.map_num - 1].y;

                    cc.log("第三波小怪已经生成！！！！！！！");
                }, i * this.cre_time_interval);

            }
        }


        // 如果生成Boss
        if (this.is_BOSS == true && this.player.player.node.x > this.x_3) {
            // 不可以再次生成
            this.is_BOSS = false;
            cc.log("BOSS已经生成");

            // 生成Boss
            let node = cc.instantiate(self.itemBOSS[this.map_num - 1]);
            // 父节点为canvas
            node.parent = this.canvas;
            // 坐标为第三波刷新点
            node.position = cc.v3(this.x_3, 0);

            // 获取Foe
            let foe = node.getComponent("Foe");
            // 设置Boss满的血量，当前血量和普攻攻击力
            foe.HP_full = self.item_ATK_HP[self.map_num - 1].z;
            foe.HP_cur = self.item_ATK_HP[self.map_num - 1].z;
            foe.ATK_num = self.item_ATK_HP[self.map_num - 1].w;
            // Boss技能攻击力为普攻3倍
            foe.Skill_num = foe.ATK_num * 3;
        }


        // 每帧检测人物是否死亡
        if (this.player.cur_HP <= 0) {
            // 死亡函数
            this.player.death();
            // cc.log("人物已经死了，死亡时血量：" + this.player.cur_HP);
        }


        // 获取金币
        let money = Number(cc.sys.localStorage.getItem("money"));
        // 在文字上显示
        this.money_lb.string = "金币：" + money;

    }


    // 创建新的小怪掉落物品  pos为生成的坐标
    create_new_drop_0 (pos: cc.Vec2) {
        // 随机数
        let num = Math.floor(this.randomNumber(0, this.item_drop.length - 1));

        cc.log("小怪随机掉落了物品,掉落的物品为数组中的", num);;
        // 随机创建掉落物品
        let node = cc.instantiate(this.item_drop[num]);
        // 父节点为canvas
        node.parent = this.canvas;
        // 设置坐标
        node.position = cc.v3(pos);
    }


    // 创建新的武器掉落物品  pos为生成的坐标  n为第几个武器  
    create_new_drop_weapon (pos: cc.Vec2, n: number) {
        // 创建新的掉落武器
        let node = cc.instantiate(this.item_drop_boos[n - 1]);
        // 设置坐标
        node.position = cc.v3(pos);
        // 父节点为canvas
        node.parent = this.canvas;
    }


    // 通关函数   显示传送门
    pass () {
        // 显示通关传送门
        this.pass_door.active = true;

        // 存储等级和经验值
        this.player.save_user_data();

        
        // 解锁下一关
        let c = Number(cc.sys.localStorage.getItem("choose"));
        if (c == this.map_num && this.map_num != 11) {
            let num = c + 1;
            cc.sys.localStorage.setItem("choose", num);
            cc.log("存储了选择关卡的数据，数据为...........................", num);
        }
    }
    


    // 增加金币专用函数   num为增加多少
    add_money (num: number) {
        // 获取金币数据
        let m = cc.sys.localStorage.getItem("money");
        // 如果没有金币
        if (m == null) {
            // 存储
            cc.sys.localStorage.setItem("money", num);
        } else {
            // 如果有金币那就加上num
            let money = Number(m) + num;
            cc.sys.localStorage.setItem("money", money);
        }
    }


    // 随机数
    randomNumber(min : number, max : number): number{
        return Math.round(Math.random() * (min - max) + max);
    }

    // 暂停游戏
    pause () {
        // 暂停游戏
        cc.director.pause();
        // 暂停游戏按钮隐藏
        this.pause_btn.active = false;
        // 继续游戏按钮显示
        this.un_pause_btn.active = true;
    }


    // 继续游戏
    un_pause () {
        // 继续游戏
        cc.director.resume();
        // 暂停游戏按钮显示
        this.pause_btn.active = true;
        // 继续游戏按钮隐藏
        this.un_pause_btn.active = false;
    }



}
